package com.roger.homecenterscreen.utils

import android.content.Context
import android.util.Log
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext
import java.io.IOException
import java.net.DatagramPacket
import java.net.DatagramSocket
import java.net.InetAddress
import java.nio.ByteBuffer
import java.util.TimeZone
import java.util.Calendar
import java.util.Date

/**
 * 网络时间同步服务
 * 使用中国的NTP服务器同步时间并设置中国时区
 */
object NetworkTimeService {
    
    private const val TAG = "NetworkTimeService"
    
    // 中国的NTP服务器列表
    private val chineseNtpServers = listOf(
        "ntp.aliyun.com",           // 阿里云NTP
        "time.pool.aliyun.com",     // 阿里云时间池
        "ntp1.aliyun.com",          // 阿里云NTP1
        "ntp2.aliyun.com",          // 阿里云NTP2
        "cn.pool.ntp.org",          // 中国NTP池
        "time1.cloud.tencent.com",  // 腾讯云NTP
        "time2.cloud.tencent.com",  // 腾讯云NTP2
        "stdtime.gov.hk",           // 香港天文台
        "202.120.2.101"             // 上海交通大学NTP
    )
    
    private const val NTP_PORT = 123
    private const val TIMEOUT = 10000 // 10秒超时
    
    /**
     * 初始化中国时区
     */
    fun initializeChinaTimeZone() {
        try {
            // 设置系统默认时区为中国时区 (GMT+8)
            TimeZone.setDefault(TimeZone.getTimeZone("Asia/Shanghai"))
            
            // 输出调试信息
            val currentTime = Calendar.getInstance(TimeZone.getTimeZone("Asia/Shanghai"))
            Log.i(TAG, "✅ 系统时区已设置为中国时区 (Asia/Shanghai)")
            Log.i(TAG, "🕐 当前中国时间: ${currentTime.time}")
            Log.i(TAG, "🌍 系统默认时区: ${TimeZone.getDefault().id}")
        } catch (e: Exception) {
            Log.e(TAG, "❌ 设置中国时区失败", e)
        }
    }
    
    /**
     * 同步网络时间
     */
    suspend fun syncNetworkTime(): Result<Long> = withContext(Dispatchers.IO) {
        return@withContext try {
            Log.i(TAG, "🕐 开始同步网络时间...")
            
            var lastException: Exception? = null
            var networkAvailable = false
            
            // 尝试多个NTP服务器
            for (server in chineseNtpServers) {
                try {
                    Log.i(TAG, "🌐 尝试连接NTP服务器: $server")
                    val networkTime = getNtpTime(server)
                    networkAvailable = true
                    
                    if (networkTime > 0) {
                        Log.i(TAG, "✅ 从 $server 获取网络时间成功")
                        Log.i(TAG, "🕐 网络时间: ${Date(networkTime)}")
                        Log.i(TAG, "🕐 本地时间: ${Date(System.currentTimeMillis())}")
                        
                        val timeDiff = networkTime - System.currentTimeMillis()
                        Log.i(TAG, "⏰ 时间差: ${timeDiff}ms")
                        
                        if (Math.abs(timeDiff) > 5000) { // 超过5秒差异才提示
                            Log.w(TAG, "⚠️ 本地时间与网络时间相差较大: ${timeDiff / 1000}秒")
                        }
                        
                        return@withContext Result.success(networkTime)
                    }
                } catch (e: IOException) {
                    Log.w(TAG, "🌐 网络连接错误 - NTP服务器 $server: ${e.message}")
                    lastException = e
                    continue
                } catch (e: Exception) {
                    Log.w(TAG, "⚠️ NTP服务器 $server 连接失败: ${e.message}")
                    lastException = e
                    continue
                }
            }
            
            // 判断是网络问题还是服务器问题
            val errorMessage = if (networkAvailable) {
                "所有NTP服务器都连接失败"
            } else {
                "网络不可用，无法同步网络时间"
            }
            
            Log.e(TAG, "❌ $errorMessage")
            Result.failure(lastException ?: Exception(errorMessage))
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ 网络时间同步异常", e)
            Result.failure(e)
        }
    }
    
    /**
     * 从NTP服务器获取时间
     */
    private suspend fun getNtpTime(server: String): Long = withContext(Dispatchers.IO) {
        var socket: DatagramSocket? = null
        
        try {
            socket = DatagramSocket()
            socket.soTimeout = TIMEOUT
            
            val address = InetAddress.getByName(server)
            
            // 构建NTP请求包
            val buffer = ByteArray(48)
            buffer[0] = 0x1B // NTP版本号和模式
            
            val request = DatagramPacket(buffer, buffer.size, address, NTP_PORT)
            socket.send(request)
            
            // 接收响应
            val response = DatagramPacket(buffer, buffer.size)
            socket.receive(response)
            
            // 解析NTP时间戳
            val responseBuffer = ByteBuffer.wrap(response.data)
            
            // NTP时间戳在字节40-43 (发送时间戳)
            responseBuffer.position(40)
            val ntpTime = responseBuffer.int.toLong() and 0xFFFFFFFFL
            
            // NTP时间基准是1900年1月1日，Unix时间基准是1970年1月1日
            // 两者相差70年，即2208988800秒
            val unixTime = (ntpTime - 2208988800L) * 1000
            
            return@withContext unixTime
            
        } catch (e: IOException) {
            Log.w(TAG, "NTP请求失败 ($server): ${e.message}")
            return@withContext 0L
        } finally {
            socket?.close()
        }
    }
    
    /**
     * 检查是否需要同步时间
     */
    fun shouldSyncTime(): Boolean {
        val lastSyncTime = getLastSyncTime()
        val currentTime = System.currentTimeMillis()
        
        // 如果从未同步过，或者距离上次同步超过1小时，则需要同步
        return lastSyncTime == 0L || (currentTime - lastSyncTime) > 3600000L
    }
    
    /**
     * 保存上次同步时间
     */
    private fun saveLastSyncTime(time: Long) {
        // 这里可以保存到SharedPreferences，简化起见直接用静态变量
        lastSyncTimeStatic = time
    }
    
    /**
     * 获取上次同步时间
     */
    private fun getLastSyncTime(): Long {
        return lastSyncTimeStatic
    }
    
    private var lastSyncTimeStatic = 0L
    
    /**
     * 获取格式化的中国时间
     */
    fun getFormattedChinaTime(): String {
        val calendar = Calendar.getInstance(TimeZone.getTimeZone("Asia/Shanghai"))
        return "${calendar.get(Calendar.YEAR)}年${calendar.get(Calendar.MONTH) + 1}月${calendar.get(Calendar.DAY_OF_MONTH)}日 " +
                "${String.format("%02d:%02d:%02d", 
                    calendar.get(Calendar.HOUR_OF_DAY), 
                    calendar.get(Calendar.MINUTE), 
                    calendar.get(Calendar.SECOND))}"
    }
    
    /**
     * 执行完整的时间同步流程
     */
    suspend fun performTimeSync(): Result<String> {
        return try {
            // 设置中国时区
            initializeChinaTimeZone()
            
            // 同步网络时间
            val syncResult = syncNetworkTime()
            
            if (syncResult.isSuccess) {
                val networkTime = syncResult.getOrNull()!!
                saveLastSyncTime(System.currentTimeMillis())
                
                val message = "时间同步成功，网络时间: ${Date(networkTime)}"
                Log.i(TAG, "✅ $message")
                Result.success(message)
            } else {
                val message = "时间同步失败: ${syncResult.exceptionOrNull()?.message}"
                Log.e(TAG, "❌ $message")
                Result.failure(syncResult.exceptionOrNull() ?: Exception(message))
            }
        } catch (e: Exception) {
            val message = "时间同步异常: ${e.message}"
            Log.e(TAG, "❌ $message", e)
            Result.failure(e)
        }
    }
} 